Artigos relacionados * [Criando pacotes](/index.php/Criando_pacotes "Criando pacotes") * [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)") * [Arch User Repository](/index.php/Arch_User_Repository_(Portugu%C3%AAs) "Arch User Repository (Português)") * [pacman](/index.php/Pacman_(Portugu%C3%AAs) "Pacman (Português)") * [Repositórios oficiais](/index.php/Reposit%C3%B3rios_oficiais "Repositórios oficiais") * [Arch Build System](/index.php/Arch_Build_System_(Portugu%C3%AAs) "Arch Build System (Português)") [makepkg](https://projects.archlinux.org/pacman.git/tree/scripts/makepkg.sh.in) é um script usado para automatizar a compilação de pacotes. Os requisitos para usar o script são uma plataforma tipo Unix capaz de compilar e um [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)"). O *makepkg* é fornecido pelo pacote [pacman](https://www.archlinux.org/packages/?name=pacman). ## Contents * [1 Configuração](#Configura.C3.A7.C3.A3o) * [1.1 Informação do empacotador](#Informa.C3.A7.C3.A3o_do_empacotador) * [1.2 Saída de pacote](#Sa.C3.ADda_de_pacote) * [1.3 Verificação de assinatura](#Verifica.C3.A7.C3.A3o_de_assinatura) * [2 Uso](#Uso) * [3 Dicas e truques](#Dicas_e_truques) * [3.1 Compilando binários otimizados](#Compilando_bin.C3.A1rios_otimizados) * [3.2 Melhorando os tempos de compilação](#Melhorando_os_tempos_de_compila.C3.A7.C3.A3o) * [3.2.1 Compilação paralela](#Compila.C3.A7.C3.A3o_paralela) * [3.2.2 Compilando de arquivos na memória](#Compilando_de_arquivos_na_mem.C3.B3ria) * [3.2.3 Usando cache de compilação](#Usando_cache_de_compila.C3.A7.C3.A3o) * [3.3 Gerar novos checksums](#Gerar_novos_checksums) * [3.4 Usar outros algoritmos de compressão](#Usar_outros_algoritmos_de_compress.C3.A3o) * [3.5 Usando vários núcleos na compressão](#Usando_v.C3.A1rios_n.C3.BAcleos_na_compress.C3.A3o) * [3.6 Mostrar pacotes com um empacotador específico](#Mostrar_pacotes_com_um_empacotador_espec.C3.ADfico) * [3.7 Compilar pacotes 32 bits em um sistema 64 bits](#Compilar_pacotes_32_bits_em_um_sistema_64_bits) * [4 Solução de problemas](#Solu.C3.A7.C3.A3o_de_problemas) * [4.1 Makepkg algumas vezes falha ao assinar um pacote sem perguntar pela palavra-chave de assinatura](#Makepkg_algumas_vezes_falha_ao_assinar_um_pacote_sem_perguntar_pela_palavra-chave_de_assinatura) * [4.2 CFLAGS/CXXFLAGS/LDFLAGS no makepkg.conf não funcionam para pacotes baseados no CMAKE](#CFLAGS.2FCXXFLAGS.2FLDFLAGS_no_makepkg.conf_n.C3.A3o_funcionam_para_pacotes_baseados_no_CMAKE) * [4.3 Especificando diretório de instalação para pacotes baseados em QMAKE](#Especificando_diret.C3.B3rio_de_instala.C3.A7.C3.A3o_para_pacotes_baseados_em_QMAKE) * [4.4 AVISO: O pacote contém referência para $srcdir](#AVISO:_O_pacote_cont.C3.A9m_refer.C3.AAncia_para_.24srcdir) * [5 Veja também](#Veja_tamb.C3.A9m) ## Configuração Veja [makepkg.conf(5)](https://jlk.fjfi.cvut.cz/arch/manpages/man/makepkg.conf.5) para detalhes sobre as opções de configuração do *makepkg*. A configuração do sistema está disponível em `/etc/makepkg.conf`, mas alterações específicas para cada usu[ario podem ser feitas em `$XDG_CONFIG_HOME/pacman/makepkg.conf` ou `~/.makepkg.conf`. É recomendado revisar a configuração antes de compilar pacotes. ### Informação do empacotador Cada pacote é marcado com metadados identificando, entre outros, também o *empacotador*. Por padrão, os pacotes compilados pelo usuário são marcados com `Empacotador desconhecido`. Se vários usuários estiverem compilando pacotes em um sistema, ou de outra forma distribuindo seus pacotes para outros usuários, é conveniente fornecer contato real. Isso pode ser feito configurando a variável `PACKAGER` em `makepkg.conf`. Para verificar isso em um pacote instalado: `$ pacman -Qi *pacote*` ``` ... Empacotador : John Doe ... ``` Para automaticamente produzir pacotes assinados, defina também a variável `GPGKEY` em `makepkg.conf`. ### Saída de pacote Por padrão, *makepkg* cria os *tarballs* de pacote no diretório atual de trabalho e baixa os dados fonte diretamente para o diretório `src/`. Caminhos personalizados podem ser configurados, por exemplo, para manter todos os pacotes compilados em `~/build/pacotes/` e todos os fontes em `~/build/fontes/`. Configure as seguintes variáveis do `makepkg.conf`, se necessário: * `PKGDEST` – diretório para armazenar pacotes resultantes * `SRCDEST` – diretório para armazenar dados [fonte](/index.php/PKGBUILD_(Portugu%C3%AAs)#source "PKGBUILD (Português)") (links simbólicos serão colocados em `src/` se ele aponta para outro lugar) * `SRCPKGDEST` – diretório para armazenar os pacotes fontes (compilado com `makepkg -S`) **Dica:** O diretório `PKGDEST` pode ser limpado com, p. ex., `paccache -c ~/build/pacotes/` como descrito em [pacman (Português)#Limpando o cache de pacotes](/index.php/Pacman_(Portugu%C3%AAs)#Limpando_o_cache_de_pacotes "Pacman (Português)"). ### Verificação de assinatura **Nota:** A verificação de assinatura implementada no *makepkg* não usa o chaveiro do pacman; em vez disso, depende do chaveiro do usuário.[[1]](http://allanmcrae.com/2015/01/two-pgp-keyrings-for-package-management-in-arch-linux/) Se um arquivo de assinatura na forma de *.sig* ou *.asc* é parte do vetor fonte do [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)"), o *makepkg* tenta automaticamente [verificá-la](/index.php/GnuPG#Verify_a_signature "GnuPG"). No caso do chaveiro do usuário não contém a chave pública necessária para verificação de assinatura, o *makepkg* vai abortar a instalação com uma mensagem de que a chave PGP não pôde ser verificada. Se uma chave pública necessária para um pacote está faltando, o [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)") muito provavelmente vai conter uma entrada [validpgpkeys](/index.php/PKGBUILD_(Portugu%C3%AAs)#validpgpkeys "PKGBUILD (Português)") com os IDs de chaves necessárias. Você pode [importá-la](/index.php/GnuPG#Import_a_public_key "GnuPG") manualmente ou você pode localizá-la [em um servidor de chaves](/index.php/GnuPG#Use_a_keyserver "GnuPG") e importá-la de lá. ## Uso Antes de continuar, [instale](/index.php/Instale "Instale") o grupo [base-devel](https://www.archlinux.org/groups/x86_64/base-devel/). Os pacotes que pertencem a este grupo **não** são exigidos na lista de dependência de compilação (*makedepends*) nos arquivos [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)"). Além disso, o grupo [base](https://www.archlinux.org/groups/x86_64/base/) é presumido como estando instalado em **todos** os sistemas Arch. **Nota:** * Certifique-se de que o [sudo](/index.php/Sudo "Sudo") está configurado corretamente para comandos passados para o [pacman](/index.php/Pacman_(Portugu%C3%AAs) "Pacman (Português)"). * Executar *makepkg* em si como root [não é permitido](https://lists.archlinux.org/pipermail/pacman-dev/2014-March/018911.html).[[2]](https://projects.archlinux.org/pacman.git/tree/NEWS) Além disso, como um `PKGBUILD` pode conter comandos arbitrários, compilar como root geralmente é considerado inseguro.[[3]](https://bbs.archlinux.org/viewtopic.php?id=67561) Usuários que não possuem acesso a uma conta de usuário comum devem executar o makepkg como o [usuário *nobody*](http://allanmcrae.com/2015/01/replacing-makepkg-asroot/). Para compilar um pacote, deve-se primeiro criar um [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)"), ou um script de compilação, como descrito em [Criando pacotes](/index.php/Criando_pacotes "Criando pacotes"). Scripts existentes estão disponíveis na árvore do [Arch Build System](/index.php/Arch_Build_System_(Portugu%C3%AAs) "Arch Build System (Português)") *(ABS)* ou do [AUR](/index.php/AUR_(Portugu%C3%AAs) "AUR (Português)"). Uma vez em posse de um `PKGBUILD`, altere o diretório no qual está salvo e execute o seguinte comando para compilar o pacote: ``` $ makepkg ``` Se estiverem faltando dependências necessárias, o *makepkg* emitirá um aviso antes de falhar. Para compilar o pacote e instalar as dependências necessárias, adicione a opção `-s/--syncdeps`: ``` $ makepkg --syncdeps ``` Adicionar as opções `-r`/`--rmdeps` faz com que o *makepkg* remova as dependências de compilação logo em seguida, já que não são mais necessárias. Se estiver compilando pacotes constantemente, considere usar [Pacman/Dicas e truques#Removendo pacotes não usados (órfãos)](/index.php/Pacman/Dicas_e_truques#Removendo_pacotes_n.C3.A3o_usados_.28.C3.B3rf.C3.A3os.29 "Pacman/Dicas e truques") de vez em quando. **Nota:** * Essas dependências devem estar disponíveis nos repositórios configurados; veja [pacman (Português)#Repositórios e espelhos](/index.php/Pacman_(Portugu%C3%AAs)#Reposit.C3.B3rios_e_espelhos "Pacman (Português)") para detalhes. Alternativamente, pode-se instalar manualmente as dependências antes de compilar (`pacman -S --asdeps *dep1* *dep2*`). * Apenas valores globais são usados ao instalar dependências, ou seja, qualquer sobrescrição feita em uma função de empacotamento de pacotes divididos não serão sadas.[[4]](https://patchwork.archlinux.org/patch/2271/) Uma vez que todas as dependências estejam satisfeitas e os pacotes compilados com sucesso, um arquivo de pacote (`*pkgname*-*pkgver*.pkg.tar.xz`) será criado no diretório. Para instalar, use `-i`/`--install` (o mesmo que `pacman -U *pkgname*-*pkgver*.pkg.tar.xz`): ``` # pacman --install ``` Para limpar arquivos e pastas restantes, tais como arquivos extraídos para $`$srcdir`, adicione a opção `-c`/`--clean`. Isso é útil para várias compilações do mesmo pacote ou ao atualizar a versão do pacote, enquanto usa a mesma pasta de compilação. Isso evita arquivos obsoletos e remanescentes de serem carregados para novas compilações: ``` $ makepkg --clean ``` Para mais informações, veja [makepkg(8)](https://www.archlinux.org/pacman/makepkg.8.html). ## Dicas e truques ### Compilando binários otimizados Uma melhoria de desempenho do software empacotado pode ser conseguida ao habilitar otimizações do compilador para a máquina host. A desvantagem é que os binários compilados para uma arquitetura de processador específica não serão executados corretamente em outras máquinas. Nas máquinas x86_64, raramente existem ganhos de desempenho reais reais significativos que justificariam investir o tempo para reconstruir pacotes oficiais. No entanto, é muito fácil reduzir o desempenho usando *flags* de compilação "não padronizadas". Muitas otimizações de compilação só são úteis em certas situações e não devem ser aplicadas indiscriminadamente em cada pacote. A menos que você possa verificar/avaliar que algo é mais rápido, há uma chance muito boa de não ser! O [Guia de Otimização de Compilação](http://www.gentoo.org/doc/en/gcc-optimization.xml) e artigo wiki [CFLAGS Seguras](http://wiki.gentoo.org/wiki/Safe_CFLAGS) do Gentoo (ambos em inglês) fornecem mais informações detalhadas sobre a otimização do compilador. As opções passadas para um compilador C/C++ (ex.: [gcc](https://www.archlinux.org/packages/?name=gcc) ou [clang](https://www.archlinux.org/packages/?name=clang)) são controladas pelas variáveis de ambiente `CFLAGS`, `CXXFLAGS` e`CPPFLAGS`. Para usar o sistema de compilação do Arch, o *makepkg* expõe essas variáveis de ambiente como opções de configuração no `makepkg.conf`. Os valores padrão são configurados para produzir binários genéricos que podem ser instalados em uma ampla gama de máquinas. **Nota:** * Tenha em mente que nem todos os sistemas de compilação usam as variáveis configuradas no `makepkg.conf`. Por exemplo, *cmake* ignora a variável de ambiente das opções de pré-processador, `CPPFLAGS`. Consequentemente, muitos [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)") contêm soluções alternativas com opções específicas para o sistema de compilação usado pelo software empacotado. * A configuração fornecida com o código fonte no `Makefile` ou em um argumento específico na linha de comando de compilação tem a preferência e pode potencialmente sobrescrever aquela no `makepkg.conf`. O GCC pode detectar e habilitar automaticamente otimizações seguras específicas para cada arquitetura. Para usar esse recurso, primeiro remova os sinalizadores `-march` e `-mtune`, então adicione `-march = native`. Por exemplo: `/etc/makepkg.conf` ``` CFLAGS="**-march=native** -O2 -pipe -fstack-protector-strong -fno-plt" CXXFLAGS="${CFLAGS}" ``` Para ver quais sinalizadores isso habilita em sua máquina, execute: ``` $ gcc -march=native -v -Q --help=target ``` **Nota:** Se você especificar um valor diferente de `-march=native`, então `-Q --help=target` **não vai** funcionar como esperado.[[5]](https://bbs.archlinux.org/viewtopic.php?pid=1616694#p1616694) Você precisa passar por uma fase de compilação para descobrir quais opções estão realmente habilitadas. Veja [Encontre opções específicas da CPU](https://wiki.gentoo.org/wiki/Safe_CFLAGS#Find_CPU-specific_options) (inglês) no wiki do Gentoo para instruções. ### Melhorando os tempos de compilação #### Compilação paralela O sistema de compilação do [make](https://www.archlinux.org/packages/?name=make) usa a [variável de ambiente](/index.php/Vari%C3%A1vel_de_ambiente "Variável de ambiente") `MAKEFLAGS` para especificar opções adicionais para o *make*. A variável também pode ser definida no arquivo `makepkg.conf`. Os usuários com sistemas multi-core/multiprocessados podem especificar o número de trabalhos a serem executados simultaneamente. Isso pode ser realizado com o uso de *nproc* para determinar o número de processadores disponíveis, ex. `MAKEFLAGS="-j$(nproc)"`. Alguns [PKGBUILD](/index.php/PKGBUILD_(Portugu%C3%AAs) "PKGBUILD (Português)") substituem especificamente isso com `-j1`, devido a condições de corrida em certas versões ou simplesmente porque não é suportado em primeiro lugar. Os pacotes que não conseguem ser compilados devido a isso devem ser [relatados](/index.php/Diretrizes_de_relat%C3%B3rios_de_erro "Diretrizes de relatórios de erro") no rastreador de erros (ou no caso dos pacotes do [AUR](/index.php/AUR_(Portugu%C3%AAs) "AUR (Português)"), ao mantenedor do pacote) depois de ter certeza de que o erro está sendo realmente causado pelo seu `MAKEFLAGS`. Veja [make(1)](https://jlk.fjfi.cvut.cz/arch/manpages/man/make.1) para uma lista completa de opções disponíveis. #### Compilando de arquivos na memória Como a compilação requer muitas operações de E/S e lidar com arquivos pequenos, mover o diretório de trabalhos para um [tmpfs](/index.php/Tmpfs "Tmpfs") pode trazer melhorias em tempos de compilação. A variável `BUILDDIR` pode ser temporariamente exportada para *makepkg* para definir o diretório de compilação para um tmpfs existente. Por exemplo: ``` $ BUILDDIR=/tmp/makepkg makepkg ``` Uma configuração persistente pode ser feita no `makepkg.conf` descomentando a opção `BUILDDIR`, que é encontrada no fim da seção `BUILD ENVIRONMENT` no arquivo padrão `/etc/makepkg.conf`. Definir esses valores para, por exemplo, `BUILDDIR=/tmp/makepkg` fará uso do sistema de arquivos temporário `/tmp` padrão do Arch. **Nota:** * Evite compilar pacotes grandes no tmpfs para evitar ficar sem memória. * A pasta tmpfs deve ser montada sem a opção `noexec`; do contrário, ela vai impedir que binparios sejam executados. * Tenha em mente que pacotes compilados no tmpfs não persistirá após reinicialização. Considere configurar a opção [PKGDEST](#Sa.C3.ADda_de_pacote) apropriadamente para mover o pacote compilado automaticamente para um diretório persistente. #### Usando cache de compilação O uso de [ccache](/index.php/Ccache_(Portugu%C3%AAs) "Ccache (Português)") pode melhorar os tempos de compilação ao armazenar em cache os resultados de compilações para uso sucessivo. ### Gerar novos checksums Instale [pacman-contrib](https://www.archlinux.org/packages/?name=pacman-contrib) e execute o seguinte comando no mesmo diretório que o arquivo PKGBUILD para gerar novas somas de verificação (*checksums*): ``` $ updpkgsums ``` As somas de verificação também podem ser obtidos com, por exemplo, `sha256sum` e adicionados ao vetor `sha256sums` manualmente. ### Usar outros algoritmos de compressão Para acelerar o empacotamento e a instalação, com a consequência de ter arquivos de pacotes maiores, você pode alterar `PKGEXT`. Por exemplo, o seguinte torna o arquivo de pacote descompactado para apenas uma invocação: ``` $ PKGEXT='.pkg.tar' makepkg ``` Um outro exemplo abaixo mostra o uso do algoritmo lzop, com o pacote [lzop](https://www.archlinux.org/packages/?name=lzop) necessário: ``` $ PKGEXT='.pkg.tar.lzo' makepkg ``` Para fazer uma dessas configurações permanentes, configure `PKGEXT` em `/etc/makepkg.conf`. ### Usando vários núcleos na compressão O [xz](https://www.archlinux.org/packages/?name=xz) oferece suporte a [multiprocessamento simétrico (SMP)](https://en.wikipedia.org/wiki/pt:Multiprocessamento_sim%C3%A9trico "wikipedia:pt:Multiprocessamento simétrico") por meio do sinalizador `--threads` para acelerar a compressão. Por exemplo, para deixar o makepkg usar quantos núcleos de CPU for possível para comprimir os pacotes, edite o vetor `COMPRESSXZ` em `/etc/makepkg.conf`: ``` COMPRESSXZ=(xz -c -z - **--threads=0**) ``` O [pigz](https://www.archlinux.org/packages/?name=pigz) é uma implementação paralela para o [gzip](https://www.archlinux.org/packages/?name=gzip) que, por padrão, usa todos os núcleos disponíveis na CPU (o sinalizador `-p/--processes` pode ser usado para empregar menos núcleos): ``` COMPRESSGZ=(**pigz** -c -f -n) ``` ### Mostrar pacotes com um empacotador específico Isso mostra todos os pacotes instalados no sistema com o empacotador chamado *nome-empacotador*: ``` $ expac "%n %p" | grep "*nome-empacotador*" | column -t ``` Isso mostra todos os pacotes instalados no sistema com o empacotador definido na variável `PACKAGER` do `/etc/makepkg`. Isso mostra apenas pacotes que estão em um repositório definido em `/etc/pacman.conf`. ``` $ . /etc/makepkg.conf; grep -xvFf <(pacman -Qqm) <(expac "%n\t%p" | grep "$PACKAGER$" | cut -f1) ``` ### Compilar pacotes 32 bits em um sistema 64 bits **Atenção:** Erros foram relatados ao usar esse método par compilar o pacote [linux](https://www.archlinux.org/packages/?name=linux). O [método de instalação](/index.php/Install_bundled_32-bit_system_in_64-bit_system "Install bundled 32-bit system in 64-bit system") é preferível e verificou-se que funciona para compilar os pacotes do kernel. Primeiro, habilite o repositório [multilib](/index.php/Multilib_(Portugu%C3%AAs) "Multilib (Português)") e [instale](/index.php/Instale "Instale") [multilib-devel](https://www.archlinux.org/groups/x86_64/multilib-devel/). Então, crie um arquivo de configuração 32 bits `~/.makepkg.i686.conf` ``` CARCH="i686" CHOST="i686-unknown-linux-gnu" CFLAGS="-m32 -march=i686 -mtune=generic -O2 -pipe -fstack-protector-strong" CXXFLAGS="${CFLAGS}" LDFLAGS="-m32 -Wl,-O1,--sort-common,--as-needed,-z,relro" ``` e chame o makepkg assim ``` $ linux32 makepkg --config ~/.makepkg.i686.conf ``` ## Solução de problemas ### Makepkg algumas vezes falha ao assinar um pacote sem perguntar pela palavra-chave de assinatura Com o [gnupg 2.1](https://www.gnupg.org/faq/whats-new-in-2.1.html), gpg-agent agora é iniciado automaticamente pelo gpg. O problema surge no estágio do pacote de `makepkg --sign`. Para permitir os privilégios corretos, [fakeroot](https://www.archlinux.org/packages/?name=fakeroot) executa a função `package()` iniciando o gpg-agent dentro do mesmo ambiente *fakeroot*. Na saída, o *fakeroot* limpa os semáforos fazendo com que a "escrita" termine o *pipe* para fechar para aquela instância do gpg-agent que resultará em um erro de *pipe* quebrado. Se o mesmo gpg-agent estiver em execução quando `makepkg --sign` estiver próximo de executado, então o gpg-agent retorna código de saída 2; então a seguinte saída ocorre: ``` ==> Assinando pacote... ==> ATENÇÃO: Falha em assinar arquivo de pacote. ``` Esse erro está atualmente sendo rastreado: [FS#49946](https://bugs.archlinux.org/task/49946). Uma solução temporária de contorno para esse problema é executar `killall gpg-agent && makepkg --sign`. Esse problema está resolvido no [pacman-git](https://aur.archlinux.org/packages/pacman-git/), especificamento no hash de commit `c6b04c04653ba9933fe978829148312e412a9ea7` ### CFLAGS/CXXFLAGS/LDFLAGS no makepkg.conf não funcionam para pacotes baseados no CMAKE Para fazer o CMake usar as variáveis definidas no arquivo de configuração do *makepkg*, passe as variáveis para *cmake* na função `build()`. Por exemplo: `PKGBUILD` ``` ... build() { ... cmake \ -DCMAKE_C_FLAGS:STRING="${CFLAGS}" \ -DCMAKE_CXX_FLAGS:STRING="${CXXFLAGS}" \ -DCMAKE_EXE_LINKER_FLAGS:STRING="${LDFLAGS}" \ -DCMAKE_SHARED_LINKER_FLAGS:STRING="${LDFLAGS}" \ ... } === CFLAGS/CXXFLAGS no makepkg.conf não funcionam para pacotes baseados no QMAKE === Qmake configura automaticamente a variável {{ic|CFLAGS}} e {{ic|CXXFLAGS}} de acordo com o que você pensa que deveria ser a configuração correta. Para deixar o qmake usar as variáveis definidas no arquivo de configuração do makepkg, você deve editar o PKGBUILD e passar as variáveis [http://doc.qt.io/qt-5/qmake-variable-reference.html#qmake-cflags QMAKE_CFLAGS] e [http://doc.qt.io/qt-5/qmake-variable-reference.html#qmake-cxxflags QMAKE_CXXFLAGS] ao qmake. Por exemplo: {{hc|PKGBUILD| ... build() { cd "$srcdir/$_pkgname-$pkgver-src" qmake-qt4 "$srcdir/$_pkgname-$pkgver-src/$_pkgname.pro" \ PREFIX=/usr \ QMAKE_CFLAGS="${CFLAGS}" \ QMAKE_CXXFLAGS="${CXXFLAGS}" make } ... ``` Alternativamente, para uma configuração para todo sistema, você pode criar seu próprio `qmake.conf` e configurar a variável de ambiente [QMAKESPEC](http://doc.qt.io/qt-5/qmake-environment-reference.html#qmakespec). ### Especificando diretório de instalação para pacotes baseados em QMAKE O makefile gerado pelo qmake usa a variável de ambiente INSTALL_ROOT para especificar onde o programa deve ser instalado. Então, essa função *package* deve funcionar: `PKGBUILD` ``` ... package() { cd "$srcdir/${pkgname%-git}" make INSTALL_ROOT="$pkgdir" install } ... ``` Note que o qmake também tem que ser configurado adequadamente. Por exemplo, coloque isso em seu arquivo .pro: `SeuProjeto.pro` ``` ... target.path = /usr/local/bin INSTALLS += target ... ``` ### AVISO: O pacote contém referência para $srcdir De alguma forma, as strings literais `$srcdir` ou `$pkgdir` acabaram em um dos arquivos instalados no seu pacote. Para identificar quais arquivos, execute o seguinte do diretório de compilação makepkg: ``` $ grep -R "$(pwd)/src" pkg/ ``` [Link](http://www.mail-archive.com/arch-general@archlinux.org/msg15561.html) para a discussão. ## Veja também * [Página de manual makepkg(8)](https://www.archlinux.org/pacman/makepkg.8.html) * [Página de manual makepkg.conf(5)](https://www.archlinux.org/pacman/makepkg.conf.5.html) * [Um breve passeio no processo do makepkg](https://gist.github.com/Earnestly/bebad057f40a662b5cc3) * [Código fonte do makepkg](https://projects.archlinux.org/pacman.git/tree/scripts/makepkg.sh.in)